juce/source/extras/the jucer/src/model/components/jucer_TabbedComponentHandler.h

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #ifndef __JUCER_TABBEDCOMPONENTHANDLER_JUCEHEADER__
  27 #define __JUCER_TABBEDCOMPONENTHANDLER_JUCEHEADER__
  28
  29
  30 //==============================================================================
  31 /**
  32 */
  33 class TabbedComponentHandler  : public ComponentTypeHandler
  34 {
  35 public:
  36     //==============================================================================
  37     TabbedComponentHandler()
  38         : ComponentTypeHandler ("Tabbed Component", "TabbedComponent", typeid (TabbedComponent), 200, 150)
  39     {}
  40
  41     //==============================================================================
  42     Component* createNewComponent (JucerDocument*)
  43     {
  44         TabbedComponent* const t = new TabbedComponent (TabbedButtonBar::TabsAtTop);
  45         t->setName ("new tabbed component");
  46
  47         for (int i = 3; --i >= 0;)
  48             addNewTab (t);
  49
  50         return t;
  51     }
  52
  53     XmlElement* createXmlFor (Component* comp, const ComponentLayout* layout)
  54     {
  55         TabbedComponent* const t = dynamic_cast <TabbedComponent*> (comp);
  56         XmlElement* const e = ComponentTypeHandler::createXmlFor (comp, layout);
  57
  58         if (t->getOrientation() == TabbedButtonBar::TabsAtTop)
  59             e->setAttribute ("orientation", "top");
  60         else if (t->getOrientation() == TabbedButtonBar::TabsAtBottom)
  61             e->setAttribute ("orientation", "bottom");
  62         else if (t->getOrientation() == TabbedButtonBar::TabsAtLeft)
  63             e->setAttribute ("orientation", "left");
  64         else if (t->getOrientation() == TabbedButtonBar::TabsAtRight)
  65             e->setAttribute ("orientation", "right");
  66
  67         e->setAttribute ("tabBarDepth", t->getTabBarDepth());
  68         e->setAttribute ("initialTab", t->getCurrentTabIndex());
  69
  70         for (int i = 0; i < t->getNumTabs(); ++i)
  71             e->addChildElement (getTabState (t, i));
  72
  73         return e;
  74     }
  75
  76     bool restoreFromXml (const XmlElement& xml, Component* comp, const ComponentLayout* layout)
  77     {
  78         if (! ComponentTypeHandler::restoreFromXml (xml, comp, layout))
  79             return false;
  80
  81         TabbedComponent* const t = dynamic_cast <TabbedComponent*> (comp);
  82
  83         if (xml.getStringAttribute ("orientation") == "top")
  84             t->setOrientation (TabbedButtonBar::TabsAtTop);
  85         else if (xml.getStringAttribute ("orientation") == "bottom")
  86             t->setOrientation (TabbedButtonBar::TabsAtBottom);
  87         else if (xml.getStringAttribute ("orientation") == "left")
  88             t->setOrientation (TabbedButtonBar::TabsAtLeft);
  89         else if (xml.getStringAttribute ("orientation") == "right")
  90             t->setOrientation (TabbedButtonBar::TabsAtRight);
  91
  92         TabbedComponent defaultTabComp (TabbedButtonBar::TabsAtTop);
  93
  94         t->setTabBarDepth (xml.getIntAttribute ("tabBarDepth", defaultTabComp.getTabBarDepth()));
  95
  96         t->clearTabs();
  97
  98         forEachXmlChildElement (xml, e)
  99         {
 100             addNewTab (t);
 101             restoreTabState (t, t->getNumTabs() - 1, *e);
 102         }
 103
 104         t->setCurrentTabIndex (xml.getIntAttribute ("initialTab", 0));
 105
 106         return true;
 107     }
 108
 109     void getEditableProperties (Component* component, JucerDocument& document, Array <PropertyComponent*>& properties)
 110     {
 111         ComponentTypeHandler::getEditableProperties (component, document, properties);
 112
 113         TabbedComponent* const t = dynamic_cast <TabbedComponent*> (component);
 114
 115         properties.add (new TabOrientationProperty (t, document));
 116         properties.add (new TabDepthProperty (t, document));
 117
 118         if (t->getNumTabs() > 0)
 119             properties.add (new TabInitialTabProperty (t, document));
 120
 121         properties.add (new TabAddTabProperty (t, document));
 122
 123         if (t->getNumTabs() > 0)
 124             properties.add (new TabRemoveTabProperty (t, document));
 125     }
 126
 127     void addPropertiesToPropertyPanel (Component* comp,
 128                                        JucerDocument& document,
 129                                        PropertyPanel& panel)
 130     {
 131         ComponentTypeHandler::addPropertiesToPropertyPanel (comp, document, panel);
 132
 133         TabbedComponent* const t = dynamic_cast <TabbedComponent*> (comp);
 134
 135         for (int i = 0; i < t->getNumTabs(); ++i)
 136         {
 137             Array <PropertyComponent*> properties;
 138
 139             properties.add (new TabNameProperty (t, document, i));
 140             properties.add (new TabColourProperty (t, document, i));
 141
 142             properties.add (new TabContentTypeProperty (t, document, i));
 143
 144             if (isTabUsingJucerComp (t, i))
 145                 properties.add (new TabJucerFileProperty (t, document, i));
 146             else
 147                 properties.add (new TabContentClassProperty (t, document, i));
 148
 149             properties.add (new TabContentConstructorParamsProperty (t, document, i));
 150
 151             properties.add (new TabMoveProperty (t, document, i, t->getNumTabs()));
 152
 153             panel.addSection ("Tab " + String (i), properties);
 154         }
 155     }
 156
 157     const String getCreationParameters (Component* comp)
 158     {
 159         TabbedComponent* const t = dynamic_cast <TabbedComponent*> (comp);
 160
 161         switch (t->getOrientation())
 162         {
 163         case TabbedButtonBar::TabsAtTop:
 164             return "TabbedButtonBar::TabsAtTop";
 165         case TabbedButtonBar::TabsAtBottom:
 166             return "TabbedButtonBar::TabsAtBottom";
 167         case TabbedButtonBar::TabsAtLeft:
 168             return "TabbedButtonBar::TabsAtLeft";
 169         case TabbedButtonBar::TabsAtRight:
 170             return "TabbedButtonBar::TabsAtRight";
 171         default:
 172             jassertfalse
 173             break;
 174         }
 175
 176         return String::empty;
 177     }
 178
 179     void fillInCreationCode (GeneratedCode& code, Component* component, const String& memberVariableName)
 180     {
 181         TabbedComponent* const t = dynamic_cast <TabbedComponent*> (component);
 182
 183         ComponentTypeHandler::fillInCreationCode (code, component, memberVariableName);
 184
 185         code.constructorCode
 186             << memberVariableName << "->setTabBarDepth (" << t->getTabBarDepth() << ");\n";
 187
 188         for (int i = 0; i < t->getNumTabs(); ++i)
 189         {
 190             String contentClassName;
 191
 192             if (isTabUsingJucerComp (t, i))
 193             {
 194                 JucerDocument* doc
 195                     = ObjectTypes::loadDocumentFromFile (code.document->getFile()
 196                                                             .getSiblingFile (getTabJucerFile (t, i)), false);
 197
 198                 if (doc != 0)
 199                 {
 200                     code.includeFilesCPP.add (getTabJucerFile (t, i).replace (".cpp", ".h"));
 201
 202                     contentClassName = doc->getClassName();
 203                     delete doc;
 204                 }
 205             }
 206             else
 207             {
 208                 contentClassName = getTabClassName (t, i);
 209             }
 210
 211             code.constructorCode
 212                 << memberVariableName
 213                 << "->addTab ("
 214                 << quotedString (t->getTabNames() [i])
 215                 << ", "
 216                 << colourToCode (t->getTabBackgroundColour (i));
 217
 218             if (contentClassName.isNotEmpty())
 219             {
 220                 code.constructorCode << ", new " << contentClassName;
 221
 222                 if (getTabConstructorParams (t, i).trim().isNotEmpty())
 223                     code.constructorCode << " ";
 224
 225                 code.constructorCode << "(" << getTabConstructorParams (t, i).trim() << "), true);\n";
 226             }
 227             else
 228             {
 229                 code.constructorCode << ", 0, false);\n";
 230             }
 231         }
 232
 233         code.constructorCode
 234             << memberVariableName << "->setCurrentTabIndex (" << t->getCurrentTabIndex() << ");\n";
 235
 236         code.constructorCode << "\n";
 237     }
 238
 239     //==============================================================================
 240     static void addNewTab (TabbedComponent* tc, const int insertIndex = -1)
 241     {
 242         tc->addTab ("Tab " + String (tc->getNumTabs()), Colours::lightgrey,
 243                     new TabDemoContentComp(), true, insertIndex);
 244     }
 245
 246     //==============================================================================
 247     static XmlElement* getTabState (TabbedComponent* tc, int tabIndex)
 248     {
 249         XmlElement* xml = new XmlElement ("TAB");
 250         xml->setAttribute ("name", tc->getTabNames() [tabIndex]);
 251         setColourXml (*xml, "colour", tc->getTabBackgroundColour (tabIndex));
 252
 253         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 254         jassert (tdc != 0);
 255
 256         if (tdc != 0)
 257         {
 258             xml->setAttribute ("useJucerComp", tdc->isUsingJucerComp);
 259             xml->setAttribute ("contentClassName", tdc->contentClassName);
 260             xml->setAttribute ("constructorParams", tdc->constructorParams);
 261             xml->setAttribute ("jucerComponentFile", tdc->jucerComponentFile);
 262         }
 263
 264         return xml;
 265     }
 266
 267     static void restoreTabState (TabbedComponent* tc, int tabIndex, const XmlElement& xml)
 268     {
 269         tc->setTabName (tabIndex, xml.getStringAttribute ("name", "Tab"));
 270         tc->setTabBackgroundColour (tabIndex, getColourXml (xml, "colour", Colours::lightgrey));
 271
 272         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 273         jassert (tdc != 0);
 274
 275         if (tdc != 0)
 276         {
 277             tdc->isUsingJucerComp = xml.getBoolAttribute ("useJucerComp", false);
 278             tdc->contentClassName = xml.getStringAttribute ("contentClassName");
 279             tdc->constructorParams = xml.getStringAttribute ("constructorParams");
 280             tdc->jucerComponentFile = xml.getStringAttribute ("jucerComponentFile");
 281
 282             tdc->updateContent();
 283         }
 284     }
 285
 286     //==============================================================================
 287     static bool isTabUsingJucerComp (TabbedComponent* tc, int tabIndex)
 288     {
 289         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 290         jassert (tdc != 0);
 291
 292         return tdc != 0 && tdc->isUsingJucerComp;
 293     }
 294
 295     static void setTabUsingJucerComp (TabbedComponent* tc, int tabIndex, const bool b)
 296     {
 297         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 298         jassert (tdc != 0);
 299
 300         if (tdc != 0)
 301         {
 302             tdc->isUsingJucerComp = b;
 303             tdc->updateContent();
 304         }
 305     }
 306
 307     static const String getTabClassName (TabbedComponent* tc, int tabIndex)
 308     {
 309         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 310         jassert (tdc != 0);
 311
 312         return tdc != 0 ? tdc->contentClassName : String::empty;
 313     }
 314
 315     static void setTabClassName (TabbedComponent* tc, int tabIndex, const String& newName)
 316     {
 317         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 318         jassert (tdc != 0);
 319
 320         if (tdc != 0)
 321         {
 322             tdc->contentClassName = newName;
 323             tdc->updateContent();
 324         }
 325     }
 326
 327     static const String getTabConstructorParams (TabbedComponent* tc, int tabIndex)
 328     {
 329         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 330         jassert (tdc != 0);
 331
 332         return tdc != 0 ? tdc->constructorParams : String::empty;
 333     }
 334
 335     static void setTabConstructorParams (TabbedComponent* tc, int tabIndex, const String& newParams)
 336     {
 337         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 338         jassert (tdc != 0);
 339
 340         if (tdc != 0)
 341         {
 342             tdc->constructorParams = newParams;
 343             tdc->updateContent();
 344         }
 345     }
 346
 347     static const String getTabJucerFile (TabbedComponent* tc, int tabIndex)
 348     {
 349         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 350         jassert (tdc != 0);
 351
 352         return tdc != 0 ? tdc->jucerComponentFile : String::empty;
 353     }
 354
 355     static void setTabJucerFile (TabbedComponent* tc, int tabIndex, const String& newFile)
 356     {
 357         TabDemoContentComp* const tdc = dynamic_cast <TabDemoContentComp*> (tc->getTabContentComponent (tabIndex));
 358         jassert (tdc != 0);
 359
 360         if (tdc != 0)
 361         {
 362             tdc->jucerComponentFile = newFile;
 363             tdc->updateContent();
 364         }
 365     }
 366
 367 private:
 368     //==============================================================================
 369     class TabDemoContentComp : public Component
 370     {
 371     public:
 372         TabDemoContentComp()
 373             : isUsingJucerComp (false)
 374         {
 375             setSize (2048, 2048);
 376         }
 377
 378         ~TabDemoContentComp()
 379         {
 380             deleteAllChildren();
 381         }
 382
 383         void paint (Graphics& g)
 384         {
 385             if (getNumChildComponents() == 0)
 386             {
 387                 g.fillCheckerBoard (getLocalBounds(), 50, 50,
 388                                     Colour::greyLevel (0.9f).withAlpha (0.4f),
 389                                     Colour::greyLevel (0.8f).withAlpha (0.4f));
 390             }
 391         }
 392
 393         void resized()
 394         {
 395             Component* const c = getChildComponent (0);
 396
 397             if (c != 0)
 398             {
 399                 c->setBounds (0, 0, getWidth(), getHeight());
 400                 setOpaque (c->isOpaque());
 401             }
 402         }
 403
 404         void updateContent()
 405         {
 406             if (isUsingJucerComp)
 407             {
 408                 TestComponent* jucerComp = dynamic_cast <TestComponent*> (getChildComponent (0));
 409
 410                 if (jucerComp == 0
 411                     || jucerComp->getOwnerDocument() == 0
 412                     || jucerComp->getFilename() != jucerComponentFile)
 413                 {
 414                     deleteAllChildren();
 415
 416                     TestComponent* tc = new TestComponent (ComponentTypeHandler::findParentDocument (this), 0, false);
 417                     tc->setFilename (jucerComponentFile);
 418                     tc->setToInitialSize();
 419
 420                     addAndMakeVisible (tc);
 421                 }
 422             }
 423             else
 424             {
 425                 deleteAllChildren();
 426             }
 427
 428             resized();
 429         }
 430
 431         void parentHierarchyChanged()
 432         {
 433             updateContent();
 434         }
 435
 436         bool isUsingJucerComp;
 437         String contentClassName, constructorParams;
 438         String jucerComponentFile;
 439     };
 440
 441     //==============================================================================
 442     class TabOrientationProperty  : public ComponentChoiceProperty <TabbedComponent>
 443     {
 444     public:
 445         TabOrientationProperty (TabbedComponent* comp, JucerDocument& document)
 446             : ComponentChoiceProperty <TabbedComponent> ("tab position", comp, document)
 447         {
 448             choices.add ("Tabs at top");
 449             choices.add ("Tabs at bottom");
 450             choices.add ("Tabs at left");
 451             choices.add ("Tabs at right");
 452         }
 453
 454         void setIndex (int newIndex)
 455         {
 456             const TabbedButtonBar::Orientation orientations[] = { TabbedButtonBar::TabsAtTop,
 457                                                                   TabbedButtonBar::TabsAtBottom,
 458                                                                   TabbedButtonBar::TabsAtLeft,
 459                                                                   TabbedButtonBar::TabsAtRight };
 460
 461             document.perform (new TabOrienationChangeAction (component, *document.getComponentLayout(), orientations [newIndex]),
 462                               "Change TabComponent orientation");
 463         }
 464
 465         int getIndex() const
 466         {
 467             switch (component->getOrientation())
 468             {
 469             case TabbedButtonBar::TabsAtTop:
 470                 return 0;
 471             case TabbedButtonBar::TabsAtBottom:
 472                 return 1;
 473             case TabbedButtonBar::TabsAtLeft:
 474                 return 2;
 475             case TabbedButtonBar::TabsAtRight:
 476                 return 3;
 477             default:
 478                 jassertfalse
 479                 break;
 480             }
 481
 482             return 0;
 483         }
 484
 485     private:
 486         class TabOrienationChangeAction  : public ComponentUndoableAction <TabbedComponent>
 487         {
 488         public:
 489             TabOrienationChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const TabbedButtonBar::Orientation newState_)
 490                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
 491                   newState (newState_)
 492             {
 493                 oldState = comp->getOrientation();
 494             }
 495
 496             bool perform()
 497             {
 498                 showCorrectTab();
 499                 getComponent()->setOrientation (newState);
 500                 changed();
 501                 return true;
 502             }
 503
 504             bool undo()
 505             {
 506                 showCorrectTab();
 507                 getComponent()->setOrientation (oldState);
 508                 changed();
 509                 return true;
 510             }
 511
 512             TabbedButtonBar::Orientation newState, oldState;
 513         };
 514     };
 515
 516     //==============================================================================
 517     class TabInitialTabProperty  : public ComponentChoiceProperty <TabbedComponent>
 518     {
 519     public:
 520         TabInitialTabProperty (TabbedComponent* comp, JucerDocument& document)
 521             : ComponentChoiceProperty <TabbedComponent> ("initial tab", comp, document)
 522         {
 523             for (int i = 0; i < comp->getNumTabs(); ++i)
 524                 choices.add ("Tab " + String (i) + ": \"" + comp->getTabNames() [i] + "\"");
 525         }
 526
 527         void setIndex (int newIndex)
 528         {
 529             document.perform (new InitialTabChangeAction (component, *document.getComponentLayout(), newIndex),
 530                               "Change initial tab");
 531         }
 532
 533         int getIndex() const
 534         {
 535             return component->getCurrentTabIndex();
 536         }
 537
 538     private:
 539         class InitialTabChangeAction  : public ComponentUndoableAction <TabbedComponent>
 540         {
 541         public:
 542             InitialTabChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const int newValue_)
 543                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
 544                   newValue (newValue_)
 545             {
 546                 oldValue = comp->getCurrentTabIndex();
 547             }
 548
 549             bool perform()
 550             {
 551                 showCorrectTab();
 552                 getComponent()->setCurrentTabIndex (newValue);
 553                 changed();
 554                 return true;
 555             }
 556
 557             bool undo()
 558             {
 559                 showCorrectTab();
 560                 getComponent()->setCurrentTabIndex (oldValue);
 561                 changed();
 562                 return true;
 563             }
 564
 565         private:
 566             int newValue, oldValue;
 567         };
 568     };
 569
 570     //==============================================================================
 571     class TabDepthProperty  : public SliderPropertyComponent,
 572                               public ChangeListener
 573     {
 574     public:
 575         TabDepthProperty (TabbedComponent* comp, JucerDocument& document_)
 576             : SliderPropertyComponent ("tab depth", 10.0, 80.0, 1.0, 1.0),
 577               component (comp),
 578               document (document_)
 579         {
 580             document.addChangeListener (this);
 581         }
 582
 583         ~TabDepthProperty()
 584         {
 585             document.removeChangeListener (this);
 586         }
 587
 588         void setValue (double newValue)
 589         {
 590             document.getUndoManager().undoCurrentTransactionOnly();
 591
 592             document.perform (new TabDepthChangeAction (component, *document.getComponentLayout(), roundToInt (newValue)),
 593                               "Change TabComponent tab depth");
 594         }
 595
 596         double getValue() const
 597         {
 598             return component->getTabBarDepth();
 599         }
 600
 601         void changeListenerCallback (ChangeBroadcaster*)
 602         {
 603             refresh();
 604         }
 605
 606         TabbedComponent* const component;
 607         JucerDocument& document;
 608
 609     private:
 610         class TabDepthChangeAction  : public ComponentUndoableAction <TabbedComponent>
 611         {
 612         public:
 613             TabDepthChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const int newState_)
 614                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
 615                   newState (newState_)
 616             {
 617                 oldState = comp->getTabBarDepth();
 618             }
 619
 620             bool perform()
 621             {
 622                 showCorrectTab();
 623                 getComponent()->setTabBarDepth (newState);
 624                 changed();
 625                 return true;
 626             }
 627
 628             bool undo()
 629             {
 630                 showCorrectTab();
 631                 getComponent()->setTabBarDepth (oldState);
 632                 changed();
 633                 return true;
 634             }
 635
 636             int newState, oldState;
 637         };
 638     };
 639
 640     //==============================================================================
 641     class TabAddTabProperty  : public ButtonPropertyComponent
 642     {
 643     public:
 644         TabAddTabProperty (TabbedComponent* comp, JucerDocument& document_)
 645             : ButtonPropertyComponent ("add tab", false),
 646               component (comp),
 647               document (document_)
 648         {
 649         }
 650
 651         void buttonClicked()
 652         {
 653             document.perform (new AddTabAction (component, *document.getComponentLayout()),
 654                               "Add a new tab");
 655         }
 656
 657         const String getButtonText() const
 658         {
 659             return "Create a new tab";
 660         }
 661
 662         TabbedComponent* const component;
 663         JucerDocument& document;
 664
 665     private:
 666         class AddTabAction  : public ComponentUndoableAction <TabbedComponent>
 667         {
 668         public:
 669             AddTabAction (TabbedComponent* const comp, ComponentLayout& layout)
 670                 : ComponentUndoableAction <TabbedComponent> (comp, layout)
 671             {
 672             }
 673
 674             bool perform()
 675             {
 676                 showCorrectTab();
 677                 addNewTab (getComponent());
 678                 layout.getDocument()->refreshAllPropertyComps();
 679                 changed();
 680                 return true;
 681             }
 682
 683             bool undo()
 684             {
 685                 showCorrectTab();
 686                 getComponent()->removeTab (getComponent()->getNumTabs() - 1);
 687                 layout.getDocument()->refreshAllPropertyComps();
 688                 changed();
 689                 return true;
 690             }
 691         };
 692     };
 693
 694     //==============================================================================
 695     class TabRemoveTabProperty  : public ButtonPropertyComponent
 696     {
 697     public:
 698         TabRemoveTabProperty (TabbedComponent* comp, JucerDocument& document_)
 699             : ButtonPropertyComponent ("remove tab", true),
 700               component (comp),
 701               document (document_)
 702         {
 703         }
 704
 705         void buttonClicked()
 706         {
 707             const StringArray names (component->getTabNames());
 708
 709             PopupMenu m;
 710             for (int i = 0; i < component->getNumTabs(); ++i)
 711                 m.addItem (i + 1, "Delete tab " + String (i)
 712                                     + ": \"" + names[i] + "\"");
 713
 714             const int r = m.showAt (this);
 715
 716             if (r > 0)
 717             {
 718                 document.perform (new RemoveTabAction (component, *document.getComponentLayout(), r - 1),
 719                                   "Remove a tab");
 720             }
 721         }
 722
 723         const String getButtonText() const
 724         {
 725             return "Delete a tab...";
 726         }
 727
 728         TabbedComponent* const component;
 729         JucerDocument& document;
 730
 731     private:
 732         class RemoveTabAction  : public ComponentUndoableAction <TabbedComponent>
 733         {
 734         public:
 735             RemoveTabAction (TabbedComponent* const comp, ComponentLayout& layout, int indexToRemove_)
 736                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
 737                   indexToRemove (indexToRemove_),
 738                   previousState (0)
 739             {
 740                 previousState = getTabState (comp, indexToRemove);
 741             }
 742
 743             ~RemoveTabAction()
 744             {
 745                 delete previousState;
 746             }
 747
 748             bool perform()
 749             {
 750                 showCorrectTab();
 751
 752                 getComponent()->removeTab (indexToRemove);
 753                 layout.getDocument()->refreshAllPropertyComps();
 754                 changed();
 755                 return true;
 756             }
 757
 758             bool undo()
 759             {
 760                 showCorrectTab();
 761                 addNewTab (getComponent(), indexToRemove);
 762                 restoreTabState (getComponent(), indexToRemove, *previousState);
 763                 layout.getDocument()->refreshAllPropertyComps();
 764                 changed();
 765                 return true;
 766             }
 767
 768         private:
 769             int indexToRemove;
 770             XmlElement* previousState;
 771         };
 772     };
 773
 774     //==============================================================================
 775     class TabNameProperty  : public ComponentTextProperty <TabbedComponent>
 776     {
 777     public:
 778         TabNameProperty (TabbedComponent* comp, JucerDocument& document, const int tabIndex_)
 779             : ComponentTextProperty <TabbedComponent> ("name", 200, false, comp, document),
 780               tabIndex (tabIndex_)
 781         {
 782         }
 783
 784         void setText (const String& newText)
 785         {
 786             document.perform (new TabNameChangeAction (component, *document.getComponentLayout(), tabIndex, newText),
 787                               "Change tab name");
 788         }
 789
 790         const String getText() const
 791         {
 792             return component->getTabNames() [tabIndex];
 793         }
 794
 795     private:
 796         int tabIndex;
 797
 798         class TabNameChangeAction  : public ComponentUndoableAction <TabbedComponent>
 799         {
 800         public:
 801             TabNameChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const int tabIndex_, const String& newValue_)
 802                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
 803                   tabIndex (tabIndex_),
 804                   newValue (newValue_)
 805             {
 806                 oldValue = comp->getTabNames() [tabIndex];
 807             }
 808
 809             bool perform()
 810             {
 811                 showCorrectTab();
 812                 getComponent()->setTabName (tabIndex, newValue);
 813                 changed();
 814                 return true;
 815             }
 816
 817             bool undo()
 818             {
 819                 showCorrectTab();
 820                 getComponent()->setTabName (tabIndex, oldValue);
 821                 changed();
 822                 return true;
 823             }
 824
 825         private:
 826             const int tabIndex;
 827             String newValue, oldValue;
 828         };
 829     };
 830
 831     //==============================================================================
 832     class TabColourProperty  : public ColourPropertyComponent,
 833                                private ChangeListener
 834     {
 835     public:
 836         TabColourProperty (TabbedComponent* comp, JucerDocument& document_, const int tabIndex_)
 837             : ColourPropertyComponent ("colour", false),
 838               component (comp),
 839               document (document_),
 840               tabIndex (tabIndex_)
 841         {
 842             document.addChangeListener (this);
 843         }
 844
 845         ~TabColourProperty()
 846         {
 847             document.removeChangeListener (this);
 848         }
 849
 850         void setColour (const Colour& newColour)
 851         {
 852             document.getUndoManager().undoCurrentTransactionOnly();
 853
 854             document.perform (new TabColourChangeAction (component, *document.getComponentLayout(), tabIndex, newColour),
 855                               "Change tab colour");
 856         }
 857
 858         const Colour getColour() const
 859         {
 860             return component->getTabBackgroundColour (tabIndex);
 861         }
 862
 863         void resetToDefault()
 864         {
 865             jassertfalse // shouldn't get called
 866         }
 867
 868         void changeListenerCallback (ChangeBroadcaster*)     { refresh(); }
 869
 870     private:
 871         TabbedComponent* component;
 872         JucerDocument& document;
 873         int tabIndex;
 874
 875         class TabColourChangeAction  : public ComponentUndoableAction <TabbedComponent>
 876         {
 877         public:
 878             TabColourChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const int tabIndex_, const Colour& newValue_)
 879                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
 880                   tabIndex (tabIndex_),
 881                   newValue (newValue_)
 882             {
 883                 oldValue = comp->getTabBackgroundColour (tabIndex);
 884             }
 885
 886             bool perform()
 887             {
 888                 showCorrectTab();
 889                 getComponent()->setTabBackgroundColour (tabIndex, newValue);
 890                 changed();
 891                 return true;
 892             }
 893
 894             bool undo()
 895             {
 896                 showCorrectTab();
 897                 getComponent()->setTabBackgroundColour (tabIndex, oldValue);
 898                 changed();
 899                 return true;
 900             }
 901
 902         private:
 903             const int tabIndex;
 904             Colour newValue, oldValue;
 905         };
 906     };
 907
 908     //==============================================================================
 909     class TabContentTypeProperty  : public ComponentChoiceProperty <TabbedComponent>
 910     {
 911     public:
 912         TabContentTypeProperty (TabbedComponent* comp, JucerDocument& document, const int tabIndex_)
 913             : ComponentChoiceProperty <TabbedComponent> ("content type", comp, document),
 914               tabIndex (tabIndex_)
 915         {
 916             choices.add ("Jucer content component");
 917             choices.add ("Named content component");
 918         }
 919
 920         void setIndex (int newIndex)
 921         {
 922             document.perform (new TabContentTypeChangeAction (component, *document.getComponentLayout(), tabIndex, newIndex == 0),
 923                               "Change tab content type");
 924         }
 925
 926         int getIndex() const
 927         {
 928             return isTabUsingJucerComp (component, tabIndex) ? 0 : 1;
 929         }
 930
 931     private:
 932         int tabIndex;
 933
 934         class TabContentTypeChangeAction  : public ComponentUndoableAction <TabbedComponent>
 935         {
 936         public:
 937             TabContentTypeChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const int tabIndex_, const bool newValue_)
 938                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
 939                   tabIndex (tabIndex_),
 940                   newValue (newValue_)
 941             {
 942                 oldValue = isTabUsingJucerComp (comp, tabIndex);
 943             }
 944
 945             bool perform()
 946             {
 947                 showCorrectTab();
 948                 setTabUsingJucerComp (getComponent(), tabIndex, newValue);
 949                 layout.getDocument()->refreshAllPropertyComps();
 950                 changed();
 951                 return true;
 952             }
 953
 954             bool undo()
 955             {
 956                 showCorrectTab();
 957                 setTabUsingJucerComp (getComponent(), tabIndex, oldValue);
 958                 layout.getDocument()->refreshAllPropertyComps();
 959                 changed();
 960                 return true;
 961             }
 962
 963         private:
 964             int tabIndex;
 965             bool newValue, oldValue;
 966         };
 967     };
 968
 969     //==============================================================================
 970     class TabJucerFileProperty   : public FilePropertyComponent,
 971                                    public ChangeListener
 972     {
 973     public:
 974         TabJucerFileProperty (TabbedComponent* const component_, JucerDocument& document_, const int tabIndex_)
 975             : FilePropertyComponent ("jucer file", false, true),
 976               component (component_),
 977               document (document_),
 978               tabIndex (tabIndex_)
 979         {
 980             document.addChangeListener (this);
 981         }
 982
 983         ~TabJucerFileProperty()
 984         {
 985             document.removeChangeListener (this);
 986         }
 987
 988         //==============================================================================
 989         void setFile (const File& newFile)
 990         {
 991             document.perform (new JucerCompFileChangeAction (component, *document.getComponentLayout(), tabIndex,
 992                                                              newFile.getRelativePathFrom (document.getFile().getParentDirectory())
 993                                                                     .replaceCharacter ('\\', '/')),
 994                               "Change tab component file");
 995         }
 996
 997         const File getFile() const
 998         {
 999             return document.getFile().getSiblingFile (getTabJucerFile (component, tabIndex));
1000         }
1001
1002         void changeListenerCallback (ChangeBroadcaster*)     { refresh(); }
1003
1004     private:
1005         TabbedComponent* const component;
1006         JucerDocument& document;
1007         int tabIndex;
1008
1009         class JucerCompFileChangeAction  : public ComponentUndoableAction <TabbedComponent>
1010         {
1011         public:
1012             JucerCompFileChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const int tabIndex_, const String& newState_)
1013                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
1014                   tabIndex (tabIndex_),
1015                   newState (newState_)
1016             {
1017                 oldState = getTabJucerFile (comp, tabIndex);
1018             }
1019
1020             bool perform()
1021             {
1022                 showCorrectTab();
1023                 setTabJucerFile (getComponent(), tabIndex, newState);
1024                 changed();
1025                 return true;
1026             }
1027
1028             bool undo()
1029             {
1030                 showCorrectTab();
1031                 setTabJucerFile (getComponent(), tabIndex, oldState);
1032                 changed();
1033                 return true;
1034             }
1035
1036             int tabIndex;
1037             String newState, oldState;
1038         };
1039     };
1040
1041     //==============================================================================
1042     class TabContentClassProperty   : public ComponentTextProperty <TabbedComponent>
1043     {
1044     public:
1045         TabContentClassProperty (TabbedComponent* comp, JucerDocument& document, const int tabIndex_)
1046             : ComponentTextProperty <TabbedComponent> ("content class", 256, false, comp, document),
1047               tabIndex (tabIndex_)
1048         {
1049         }
1050
1051         void setText (const String& newText)
1052         {
1053             document.perform (new TabClassNameChangeAction (component, *document.getComponentLayout(), tabIndex, newText),
1054                               "Change TabbedComponent content class");
1055         }
1056
1057         const String getText() const
1058         {
1059             return getTabClassName (component, tabIndex);
1060         }
1061
1062     private:
1063         int tabIndex;
1064
1065         class TabClassNameChangeAction  : public ComponentUndoableAction <TabbedComponent>
1066         {
1067         public:
1068             TabClassNameChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const int tabIndex_, const String& newValue_)
1069                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
1070                   tabIndex (tabIndex_),
1071                   newValue (newValue_)
1072             {
1073                 oldValue = getTabClassName (comp, tabIndex);
1074             }
1075
1076             bool perform()
1077             {
1078                 showCorrectTab();
1079                 setTabClassName (getComponent(), tabIndex, newValue);
1080                 changed();
1081                 layout.getDocument()->refreshAllPropertyComps();
1082                 return true;
1083             }
1084
1085             bool undo()
1086             {
1087                 showCorrectTab();
1088                 setTabClassName (getComponent(), tabIndex, oldValue);
1089                 changed();
1090                 layout.getDocument()->refreshAllPropertyComps();
1091                 return true;
1092             }
1093
1094             int tabIndex;
1095             String newValue, oldValue;
1096         };
1097     };
1098
1099     //==============================================================================
1100     class TabContentConstructorParamsProperty   : public ComponentTextProperty <TabbedComponent>
1101     {
1102     public:
1103         TabContentConstructorParamsProperty (TabbedComponent* comp, JucerDocument& document, const int tabIndex_)
1104             : ComponentTextProperty <TabbedComponent> ("constructor params", 512, false, comp, document),
1105               tabIndex (tabIndex_)
1106         {
1107         }
1108
1109         void setText (const String& newText)
1110         {
1111             document.perform (new TabConstructorParamChangeAction (component, *document.getComponentLayout(), tabIndex, newText),
1112                               "Change TabbedComponent content constructor param");
1113         }
1114
1115         const String getText() const
1116         {
1117             return getTabConstructorParams (component, tabIndex);
1118         }
1119
1120     private:
1121         int tabIndex;
1122
1123         class TabConstructorParamChangeAction  : public ComponentUndoableAction <TabbedComponent>
1124         {
1125         public:
1126             TabConstructorParamChangeAction (TabbedComponent* const comp, ComponentLayout& layout, const int tabIndex_, const String& newValue_)
1127                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
1128                   tabIndex (tabIndex_),
1129                   newValue (newValue_)
1130             {
1131                 oldValue = getTabConstructorParams (comp, tabIndex);
1132             }
1133
1134             bool perform()
1135             {
1136                 showCorrectTab();
1137                 setTabConstructorParams (getComponent(), tabIndex, newValue);
1138                 changed();
1139                 layout.getDocument()->refreshAllPropertyComps();
1140                 return true;
1141             }
1142
1143             bool undo()
1144             {
1145                 showCorrectTab();
1146                 setTabConstructorParams (getComponent(), tabIndex, oldValue);
1147                 changed();
1148                 layout.getDocument()->refreshAllPropertyComps();
1149                 return true;
1150             }
1151
1152             int tabIndex;
1153             String newValue, oldValue;
1154         };
1155     };
1156
1157     //==============================================================================
1158     class TabMoveProperty   : public ButtonPropertyComponent
1159     {
1160     public:
1161         TabMoveProperty (TabbedComponent* comp, JucerDocument& document_,
1162                          const int tabIndex_, const int totalNumTabs_)
1163             : ButtonPropertyComponent ("move tab", false),
1164               component (comp),
1165               document (document_),
1166               tabIndex (tabIndex_),
1167               totalNumTabs (totalNumTabs_)
1168         {
1169
1170         }
1171
1172         void buttonClicked()
1173         {
1174             PopupMenu m;
1175             m.addItem (1, "Move this tab up", tabIndex > 0);
1176             m.addItem (2, "Move this tab down", tabIndex < totalNumTabs - 1);
1177
1178             const int r = m.showAt (this);
1179
1180             if (r != 0)
1181             {
1182                 document.perform (new MoveTabAction (component, *document.getComponentLayout(), tabIndex, tabIndex + (r == 2 ? 1 : -1)),
1183                                   "Move a tab");
1184             }
1185         }
1186
1187         const String getButtonText() const
1188         {
1189             return "Move this tab...";
1190         }
1191
1192         TabbedComponent* const component;
1193         JucerDocument& document;
1194         const int tabIndex, totalNumTabs;
1195
1196     private:
1197         class MoveTabAction  : public ComponentUndoableAction <TabbedComponent>
1198         {
1199         public:
1200             MoveTabAction (TabbedComponent* const comp, ComponentLayout& layout,
1201                            const int oldIndex_, const int newIndex_)
1202                 : ComponentUndoableAction <TabbedComponent> (comp, layout),
1203                   oldIndex (oldIndex_),
1204                   newIndex (newIndex_)
1205             {
1206             }
1207
1208             void move (int from, int to)
1209             {
1210                 showCorrectTab();
1211
1212                 XmlElement* const state = getTabState (getComponent(), from);
1213
1214                 getComponent()->removeTab (from);
1215                 addNewTab (getComponent(), to);
1216
1217                 restoreTabState (getComponent(), to, *state);
1218                 delete state;
1219
1220                 layout.getDocument()->refreshAllPropertyComps();
1221                 changed();
1222             }
1223
1224             bool perform()
1225             {
1226                 move (oldIndex, newIndex);
1227                 return true;
1228             }
1229
1230             bool undo()
1231             {
1232                 move (newIndex, oldIndex);
1233                 return true;
1234             }
1235
1236         private:
1237             const int oldIndex, newIndex;
1238         };
1239     };
1240 };
1241
1242
1243 #endif   // __JUCER_TABBEDCOMPONENTHANDLER_JUCEHEADER__